package Both;

/**
 * Polytech' Nice - Sophia Antipolis / SI3 / Projet de fin de semestre
 * Annee 2011_2012
 * 
 * Reservation de transports en commun
 * 
 * Package Both
 * 
 * Enum TypeTransport : represente tous les types de transport geres par l'application
 * 
 * @author J. Harnetiaux, N. Potier
 */

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;

public enum TypeTransport implements Serializable {
    AVION("avion"), VOITURE("voiture"), BATEAU("bateau"), BUS("bus"), TRAIN(
            "train"), UNKNOWN("unknown");

    // Prix des moyens de transport au kilometre
    //
    private static final double PRIX_AVION = 0.25; // Paris - NY ==> 6000km,
                                                   // envrion 1000�
    private static final double PRIX_VOITURE = 0.09; // 800km par plein, environ
                                                     // 60� le plein
    private static final double PRIX_BATEAU = 0.17;
    private static final double PRIX_BUS = 1.00; // Prix fixe peu importe le
                                                 // trajet
    private static final double PRIX_TRAIN = 0.14;

    private String transportString;

    TypeTransport() {
    }

    /**
     * constructeur normal
     */
    TypeTransport(String transportString) {
        this.transportString = transportString;
    }

    /**
     * methode toString pour l'affichage
     * 
     * @return The transport as a string.
     */
    public String toString() {
        return transportString;
    }

    /**
     * permet de renvoyer le type du transport en String
     * 
     * @return String type du transport
     */
    public String getTransportString() {
        return transportString;
    }

    /**
     * Fourni la grille des tarifs de base pour chaque transport Ces tarifs
     * varieront en fonction de la distance, des services souscris, etc.
     * 
     * @return la grille des tarifs sous forme de HashMap
     */
    public static HashMap<String, Double> getTarifs() {
        // Construire et remplir le dictionnaire resultant
        //
        HashMap<String, Double> tarifs = new HashMap<String, Double>();
        tarifs.put(AVION.getTransportString(), PRIX_AVION);
        tarifs.put(BATEAU.getTransportString(), PRIX_BATEAU);
        tarifs.put(VOITURE.getTransportString(), PRIX_VOITURE);
        tarifs.put(BUS.getTransportString(), PRIX_BUS);
        tarifs.put(TRAIN.getTransportString(), PRIX_TRAIN);

        return tarifs;
    }

    /**
     * Retourne la valeur de l'enum associee a la valeur passee en parametre
     * 
     * @param value
     *            valeur associee a l'enum qu'on veut recuperer
     * @return la valeur de l'enum associee a la valeur passee en parametre
     */
    public static TypeTransport toTypeTransport(String value) {
        value = value.toUpperCase();
        TypeTransport retour = null;
        try {
            retour = Enum.valueOf(TypeTransport.class, value);
        } catch (Exception e) {
            retour = UNKNOWN;
        }
        return retour;
    }

    /**
     * retourne une liste des TypeTransport
     * 
     * @return ArrayListe<TypeTransport>
     */
    public static ArrayList<TypeTransport> allType() {
        ArrayList<TypeTransport> listType = new ArrayList<TypeTransport>();
        TypeTransport[] tableType = TypeTransport.values();
        for (TypeTransport Type : tableType) {
            listType.add(Type);
        }
        return listType;
    }

    /**
     * Retourne le tarifs de base du transport Ce tarif variera en fonction de
     * la distance, des services souscris, etc.
     * 
     * @return la tarif de base du type de transport choisi
     */
    public double getTarif() {
        return getTarifs().get(getTransportString());
    }

    /**
     * Fourni la grille des services et leur tarifs pour chaque type de
     * transport
     * 
     * @return la grille des services pour chaque transport
     */
    public static HashMap<String, HashMap<String, Double>> getServices() {
        // Construire et remplir le dictionnaire des services pour chaque type
        // de trajet
        //
        HashMap<String, Double> servicesAvion = getServicesAvion();
        HashMap<String, Double> servicesVoiture = null;
        HashMap<String, Double> servicesBateau = getServicesBateau();
        HashMap<String, Double> servicesBus = null;
        HashMap<String, Double> servicesTrain = getServicesTrain();

        // Construire et remplir le dictionnaire resultant
        //
        HashMap<String, HashMap<String, Double>> services = new HashMap<String, HashMap<String, Double>>();
        services.put(AVION.getTransportString(), servicesAvion);
        services.put(VOITURE.getTransportString(), servicesVoiture);
        services.put(BATEAU.getTransportString(), servicesBateau);
        services.put(BUS.getTransportString(), servicesBus);
        services.put(TRAIN.getTransportString(), servicesTrain);

        // Retourner le dictionnaire r�sultant
        //
        return services;
    }

    /**
     * Fourni la grille des services d'un avion et leur tarif
     * 
     * @return la grille des services d'un avion
     */
    private static HashMap<String, Double> getServicesAvion() {
        // Construire et remplir le dictionnaire resultant
        //
        HashMap<String, Double> servicesAvion = new HashMap<String, Double>();
        servicesAvion.put("Classe affaire", 56.30);
        servicesAvion.put("Repas", 35.20);

        // Retourner le dictionnaire resultant
        //
        return servicesAvion;
    }

    /**
     * Fourni la grille des services d'un bateau et leur tarif
     * 
     * @return la grille des services d'un bateau
     */
    private static HashMap<String, Double> getServicesBateau() {
        // Construire et remplir le dictionnaire resultant
        //
        HashMap<String, Double> servicesBateau = new HashMap<String, Double>();
        servicesBateau.put("croisiere", 325.00);
        servicesBateau.put("repas", 25.50);
        servicesBateau.put("couchette", 32.00);

        // Retourner le dictionnaire resultant
        //
        return servicesBateau;
    }

    /**
     * Fourni la grille des services d'un train et leur tarif
     * 
     * @return la grille des services d'un train
     */
    private static HashMap<String, Double> getServicesTrain() {
        // Construire et remplir le dictionnaire resultant
        //
        HashMap<String, Double> servicesTrain = new HashMap<String, Double>();
        servicesTrain.put("premiere classe", 15.00);
        servicesTrain.put("repas", 18.50);
        servicesTrain.put("couchette", 20.00);

        // Retourner le dictionnaire resultant
        //
        return servicesTrain;
    }

    /**
     * Retourne les services disponibles pour la valeur de l'enum
     * 
     * @return les services disponibles pour le type de transport choisi
     */
    public HashMap<String, Double> getServicesDisponibles() {
        return getServices().get(getTransportString());
    }
}
